template <typename T>
DiccTrie<T>::DiccTrie()
{
    raiz = new Nodo;
}

template <typename T>
unsigned int DiccTrie<T>::toInt(const char c) const{
    unsigned int res(tolower(c));    //No diferenciamos caps
    return res;
}

template <typename T>
void DiccTrie<T>::definir(const String& clave, T* significado)
{
    assert(!definido(clave));
    Nodo* aux = NULL;
    int letra;

    if(clave.size() == 0){
        raiz->significado = significado;
    }else{
        aux = raiz;
        for(aed2::Nat i=0; i < clave.size(); i++){
            letra = toInt(clave[i]);

            //Defino en cada letra si corresponde en el arreglo de nodos
            if( (aux->nodos)[letra] == NULL ){
                Nodo* nuevoNodo = new Nodo();
                (aux->nodos).Definir(letra,nuevoNodo);
            }

            //Asigno el significado correspondiente
            aux = (aux->nodos)[letra];
            if( i == (clave.size()-1) ){
                aux->significado = significado;
            }
        }
    }
}

template <typename T>
typename DiccTrie<T>::Nodo* DiccTrie<T>::obtenerNodo(const String& clave) const
{
    Nodo* res = raiz;
    int letra = 0;
    aed2::Nat i = 0;

    while(res != NULL && i < clave.size()){
        letra = toInt(clave[i]);
        res = (res->nodos)[letra];
        i++;
    }

    return res;
}


template <typename T>
bool DiccTrie<T>::definido(const String& clave) const
{
    Nodo* res = obtenerNodo(clave);
    return res != NULL && res->significado != NULL;
}

template <typename T>
T& DiccTrie<T>::obtener(const String& clave) const
{
    assert(definido(clave));
    Nodo* res = obtenerNodo(clave);
    return *(res->significado);
}

template <typename T>
void DiccTrie<T>::borrar(const String& clave)
{
    assert(definido(clave));
    Nodo* victima = obtenerNodo(clave);
    delete victima->significado;
    victima->significado = NULL;
}

template <typename T>
void DiccTrie<T>::borrarTodos(Nodo* victima){
    for(int i=0; i < 255; i++){
        if((victima->nodos)[i] != NULL){
            borrarTodos((victima->nodos)[i]);
        }
    }
    delete victima;
}

template <typename T>
DiccTrie<T>::~DiccTrie()
{
    //std::cout << "Me borro " << this << std::endl;
    borrarTodos(raiz);
}
